package com.java8.sgg.stream;

import com.java8.sgg.method.Employee;
import com.java8.sgg.method.EmployeeData;
import org.junit.Test;

import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

/**
 * 1.Stream关注的是数据的运算，与CPU打交道
 * 集合关注的是数据的存储，与内存打交道。
 * <p>
 * 2.
 * >Stream自己不会存储元素。
 * >Stream不会改变源对象，相反，他们会返回一个持有结果的新Stream.
 * >Stream操作是延迟执行的，这意味着他们会等到需要结果的时候才执行。
 * <p>
 * 3.Stream的执行流程
 * >stream的执行流程
 * >一系列的中间操作(过滤，映射....)
 * >终止操作
 * <p>
 * 4. 说明
 * >一个中间操作链，对数据源的数据进行处理
 * >一旦执行终止操作，就执行中间操作链，并产生结果，之后，不会再被使用
 */

public class StreamAPITest {

    //创建Stream方式一: 通过集合
    @Test
    public void test1() {

        List<Employee> employees = EmployeeData.getEmployees();

        //default Stream<E> stream() :返回一个顺序流
        Stream<Employee> stream = employees.stream();


        //default Stream<E> parallelStream() : 返回一个并行流
        Stream<Employee> employeeStream = employees.parallelStream();

    }


    //创建Stream方式二: 通过数组
    @Test
    public void test2() {
        /**
         * java8中的Arrays的静态方法stream()可以获取数组流:
         *
         * static<T> Stream<T> stream(T[] array):返回一个流
         *
         * 重载形式,能够处理对应基本类型的数组:
         *
         *
         * >public static IntStream stream(int[] array)
         * >public static LongStream stream(long[] array)
         * >public static DoubleStream stream(double[] array)
         *
         */

        int[] arr = new int[]{1, 2, 3, 4, 5, 6};

        //调用Arrays类的static<T> Stream<T> stream(T[] array):返回一个流
        IntStream stream = Arrays.stream(arr);

        Employee employee1 = new Employee(1001, "Tom");
        Employee employee2 = new Employee(1002, "Jerry");

        Employee[] arr1 = new Employee[]{employee1, employee2};
        //此处通过泛型
        Stream<Employee> stream1 = Arrays.stream(arr1);

    }


    //创建Stream方式三: 通过Stream的of()

    /**
     * 可以调用Stream类静态方法of(),通过显式值创建一个流。它可以接收任意数量的参数
     */
    @Test
    public void test3() {

        //此处1,2,3...是包装类，不是int,是Integer
        Stream<Integer> integerStream = Stream.of(1, 2, 3, 4, 5, 6);

    }

    /**
     * 创建Stream方式四: 创建无限流
     * 可以使用静态方法Stream.iterate()和Stream.generate(),创建无限流
     *
     * 迭代
     * public static<T> Stream<T> iterate(final T seed, final UnaryOperator<T> f)
     *
     * 生成
     * public static<T> Stream<T> generate(Supplier<T> s)
     *
     */
    @Test
    public void test4() {

        //迭代
        //遍历前10个偶数
        Stream.iterate(0, t -> t + 2).limit(10).forEach(System.out::println);


        //生成
        Stream.generate(Math::random).limit(10).forEach(System.out::println);

    }
}
